package com.star.util.common;

import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.springframework.util.CollectionUtils;

import com.star.util.file.FileUtil;

public class GenericUtils {

	/**
	 * 通过反射,获得指定类的父类的泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>
	 * 
	 * @param clazz
	 *            clazz 需要反射的类,该类必须继承范型父类
	 * @param index
	 *            泛型参数所在索引,从0开始.
	 * @return 范型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
	 *         <code>Object.class</code>
	 */
	@SuppressWarnings("rawtypes")
	public static Class getSuperClassGenricType(Class clazz, int index) {
		Type genType = clazz.getGenericSuperclass();// 得到泛型父类

		// 如果没有实现ParameterizedType接口，即不支持泛型，直接返回Object.class

		if (!(genType instanceof ParameterizedType)) {
			return Object.class;
		}
		// 返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends

		// DaoSupport<Buyer,Contact>就返回Buyer和Contact类型

		Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
		if (index >= params.length || index < 0) {
			throw new RuntimeException("你输入的索引"
					+ (index < 0 ? "不能小于0" : "超出了参数的总数"));
		}
		if (!(params[index] instanceof Class)) {
			return Object.class;
		}
		return (Class) params[index];
	}

	/**
	 * 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>
	 * 
	 * @param clazz
	 *            clazz 需要反射的类,该类必须继承泛型父类
	 * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
	 *         <code>Object.class</code>
	 */
	@SuppressWarnings("rawtypes")
	public static Class getSuperClassGenricType(Class clazz) {
		return getSuperClassGenricType(clazz, 0);
	}

	/**
	 * 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
	 * 
	 * @param Method
	 *            method 方法
	 * @param int index 泛型参数所在索引,从0开始.
	 * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
	 *         <code>Object.class</code>
	 */
	@SuppressWarnings("rawtypes")
	public static Class getMethodGenericReturnType(Method method, int index) {
		Type returnType = method.getGenericReturnType();
		if (returnType instanceof ParameterizedType) {
			ParameterizedType type = (ParameterizedType) returnType;
			Type[] typeArguments = type.getActualTypeArguments();
			if (index >= typeArguments.length || index < 0) {
				throw new RuntimeException("你输入的索引"
						+ (index < 0 ? "不能小于0" : "超出了参数的总数"));
			}
			return (Class) typeArguments[index];
		}
		return Object.class;
	}

	/**
	 * 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
	 * 
	 * @param Method
	 *            method 方法
	 * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
	 *         <code>Object.class</code>
	 */
	@SuppressWarnings("rawtypes")
	public static Class getMethodGenericReturnType(Method method) {
		return getMethodGenericReturnType(method, 0);
	}

	/**
	 * 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String,
	 * Buyer> maps, List<String> names){}
	 * 
	 * @param Method
	 *            method 方法
	 * @param int index 第几个输入参数
	 * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
	 */
	@SuppressWarnings("rawtypes")
	public static List<Class> getMethodGenericParameterTypes(Method method,
			int index) {
		List<Class> results = new ArrayList<Class>();
		Type[] genericParameterTypes = method.getGenericParameterTypes();
		if (index >= genericParameterTypes.length || index < 0) {
			throw new RuntimeException("你输入的索引"
					+ (index < 0 ? "不能小于0" : "超出了参数的总数"));
		}
		Type genericParameterType = genericParameterTypes[index];
		if (genericParameterType instanceof ParameterizedType) {
			ParameterizedType aType = (ParameterizedType) genericParameterType;
			Type[] parameterArgTypes = aType.getActualTypeArguments();
			for (Type parameterArgType : parameterArgTypes) {
				Class parameterArgClass = (Class) parameterArgType;
				results.add(parameterArgClass);
			}
			return results;
		}
		return results;
	}

	/**
	 * 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer>
	 * maps, List<String> names){}
	 * 
	 * @param Method
	 *            method 方法
	 * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
	 */
	@SuppressWarnings("rawtypes")
	public static List<Class> getMethodGenericParameterTypes(Method method) {
		return getMethodGenericParameterTypes(method, 0);
	}

	/**
	 * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
	 * 
	 * @param Field
	 *            field 字段
	 * @param int index 泛型参数所在索引,从0开始.
	 * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
	 *         <code>Object.class</code>
	 */
	@SuppressWarnings("rawtypes")
	public static Class getFieldGenericType(Field field, int index) {
		Type genericFieldType = field.getGenericType();

		if (genericFieldType instanceof ParameterizedType) {
			ParameterizedType aType = (ParameterizedType) genericFieldType;
			Type[] fieldArgTypes = aType.getActualTypeArguments();
			if (index >= fieldArgTypes.length || index < 0) {
				throw new RuntimeException("你输入的索引"
						+ (index < 0 ? "不能小于0" : "超出了参数的总数"));
			}
			return (Class) fieldArgTypes[index];
		}
		return Object.class;
	}

	/**
	 * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
	 * 
	 * @param Field
	 *            field 字段
	 * @param int index 泛型参数所在索引,从0开始.
	 * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
	 *         <code>Object.class</code>
	 */
	@SuppressWarnings("rawtypes")
	public static Class getFieldGenericType(Field field) {
		return getFieldGenericType(field, 0);
	}

	/**
	 * 用该方法来代替 {@code new HashMap<K, V>()} 方式获得新的 {@code java.util.Map} 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @return 返回 {@code java.util.Map<K, V>} 关于 {@code java.util.HashMap<K, V>}
	 *         实现的新实例。
	 */
	public static <K, V> Map<K, V> getMap() {
		return new HashMap<K, V>();
	}

	/**
	 * 用该方法来代替 {@code new HashMap<K, V>(int)} 方式获得新的 {@code java.util.Map}
	 * 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @param initialCapacity
	 *            初始容量。
	 * @return 返回 {@code java.util.Map<K, V>} 关于 {@code java.util.HashMap<K, V>}
	 *         实现的新实例。
	 */
	public static <K, V> Map<K, V> getMap(int initialCapacity) {
		return new HashMap<K, V>(initialCapacity);
	}

	/**
	 * 用该方法来代替 {@code new ConcurrentHashMap<K, V>()} 方式获得新的
	 * {@code java.util.Map} 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @return 返回 {@code java.util.Map<K, V>} 关于
	 *         {@code java.util.concurrent.ConcurrentHashMap<K, V>} 实现的新实例。
	 */
	public static <K, V> Map<K, V> getConcurrentMap() {
		return new ConcurrentHashMap<K, V>();
	}

	/**
	 * 用该方法来代替 {@code new ConcurrentHashMap<K, V>(int)} 方式获得新的
	 * {@code java.util.Map} 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @param initialCapacity
	 *            初始容量。
	 * @return 返回 {@code java.util.Map<K, V>} 关于
	 *         {@code java.util.concurrent.ConcurrentHashMap<K, V>} 实现的新实例。
	 */
	public static <K, V> Map<K, V> getConcurrentMap(int initialCapacity) {
		return new ConcurrentHashMap<K, V>(initialCapacity);
	}

	/**
	 * 用该方法来代替 {@code new LinkedHashMap<K, V>()} 方式获得新的 {@code java.util.Map}
	 * 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @return 返回 {@code java.util.Map<K, V>} 关于
	 *         {@code java.util.LinkedHashMap<K, V>} 实现的新实例。
	 */
	public static <K, V> Map<K, V> getLinkedMap() {
		return new LinkedHashMap<K, V>();
	}

	/**
	 * 用该方法来代替 {@code new LinkedHashMap<K, V>(int)} 方式获得新的 {@code java.util.Map}
	 * 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @param initialCapacity
	 *            初始容量。
	 * @return 返回 {@code java.util.Map<K, V>} 关于
	 *         {@code java.util.LinkedHashMap<K, V>} 实现的新实例。
	 */
	public static <K, V> Map<K, V> getLinkedMap(int initialCapacity) {
		return new LinkedHashMap<K, V>(initialCapacity);
	}

	/**
	 * 用该方法来代替 {@code new TreeMap<K, V>()} 方式获得新的 {@code java.util.Map} 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @return 返回 {@code java.util.Map<K, V>} 关于 {@code java.util.TreeMap<K, V>}
	 *         实现的新实例。
	 */
	public static <K, V> Map<K, V> getTreeMap() {
		return new TreeMap<K, V>();
	}

	/**
	 * 用该方法来代替 {@code new ConcurrentHashMap<K, V>()} 方式获得新的
	 * {@code java.util.concurrent.ConcurrentHashMap} 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @return 返回 {@code java.util.concurrent.ConcurrentMap<K, V>} 关于
	 *         {@code java.util.concurrent.ConcurrentHashMap<K, V>} 实现的新实例。
	 */
	public static <K, V> ConcurrentMap<K, V> getConcurrentHashMap() {
		return new ConcurrentHashMap<K, V>();
	}

	/**
	 * 用该方法来代替 {@code new ConcurrentHashMap<K, V>(int)} 方式获得新的
	 * {@code java.util.concurrent.ConcurrentHashMap} 的实例对象。
	 * 
	 * @param <K>
	 *            {@code Map} 中的键对象。
	 * @param <V>
	 *            {@code Map} 中的值对象。
	 * @param initialCapacity
	 *            初始容量。
	 * @return 返回 {@code java.util.concurrent.ConcurrentMap<K, V>} 关于
	 *         {@code java.util.concurrent.ConcurrentHashMap<K, V>} 实现的新实例。
	 */
	public static <K, V> ConcurrentMap<K, V> getConcurrentHashMap(
			int initialCapacity) {
		return new ConcurrentHashMap<K, V>(initialCapacity);
	}

	/**
	 * 用该方法来代替 {@code new ArrayList<T>()} 方式获得新的 {@code java.util.List} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code List<T>} 中保存的对象。
	 * @return 返回 {@code java.util.List<T>} 关于 {@code java.util.ArrayList<T>}
	 *         实现的新实例。
	 */
	public static <T> List<T> getList() {
		return new ArrayList<T>();
	}

	/**
	 * 用该方法来代替 {@code new ArrayList<T>(int)} 方式获得新的 {@code java.util.List}
	 * 的实例对象。
	 * 
	 * @param <T>
	 *            {@code List<T>} 中保存的对象。
	 * @param initialCapacity
	 *            列表的初始容量。
	 * @return 返回 {@code java.util.List<T>} 关于 {@code java.util.ArrayList<T>}
	 *         实现的新实例。
	 */
	public static <T> List<T> getList(int initialCapacity) {
		return new ArrayList<T>(initialCapacity);
	}

	/**
	 * 用该方法来代替 {@code new ArrayList<T>()} 方式获得新的 {@code java.util.List} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code List<T>} 中保存的对象。
	 * @param c
	 *            其中的元素将存放在新的 {@code list} 中的 {@code collection}。
	 * @return 返回 {@code java.util.List<T>} 关于 {@code java.util.ArrayList<T>}
	 *         实现的新实例。
	 */
	public static <T> List<T> getList(Collection<? extends T> c) {
		if (!CollectionUtils.isEmpty(c))
			return new ArrayList<T>(c);
		return new ArrayList<T>();
	}

	/**
	 * 用该方法来代替 {@code new LinkedList<T>()} 方式获得新的 {@code java.util.List} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code List<T>} 中保存的对象。
	 * @return 返回 {@code java.util.List<T>} 关于 {@code java.util.LinkedList<T>}
	 *         实现的新实例。
	 */
	public static <T> List<T> getLinkedList() {
		return new LinkedList<T>();
	}

	/**
	 * 用该方法来代替 {@code new HashSet<T>()} 方式获得新的 {@code java.util.Set} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code Set<T>} 中保存的对象。
	 * @return 返回 {@code java.util.Set<T>} 关于 {@code java.util.HashSet<T>}
	 *         实现的新实例。
	 */
	public static <T> Set<T> getHashSet() {
		return new HashSet<T>();
	}

	/**
	 * 用该方法来代替 {@code new HashSet<T>(int)} 方式获得新的 {@code java.util.Set} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code Set<T>} 中保存的对象。
	 * @param initialCapacity
	 *            列表的初始容量。
	 * @return 返回 {@code java.util.Set<T>} 关于 {@code java.util.HashSet<T>}
	 *         实现的新实例。
	 */
	public static <T> Set<T> getHashSet(int initialCapacity) {
		return new HashSet<T>(initialCapacity);
	}

	/**
	 * 用该方法来代替 <code>new HashSet<T>(Collection<? extends T> c)</code> 方式获得新的
	 * {@code java.util.Set} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code Set} 中保存的对象。
	 * @param c
	 *            其中的元素将存放在新的 {@code set} 中的 {@code collection}。
	 * @return 返回 {@code java.util.Set<T>} 关于 {@code java.util.HashSet<T>}
	 *         实现的新实例。
	 */
	public static <T> Set<T> getHashSet(Collection<? extends T> c) {
		if (CollectionUtils.isEmpty(c))
			return new HashSet<T>();
		return new HashSet<T>(c);
	}

	/**
	 * 用该方法来代替 {@code new TreeSet<T>()} 方式获得新的 {@code java.util.Set} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code Set<T>} 中保存的对象。
	 * @return 返回 {@code java.util.Set<T>} 关于 {@code java.util.TreeSet<T>}
	 *         实现的新实例。
	 */
	public static <T> Set<T> getTreeSet() {
		return new TreeSet<T>();
	}

	/**
	 * 用该方法来代替 <code>new TreeSet<T>(Collection<? extends T> c)</code> 方式获得新的
	 * {@code java.util.Set} 的实例对象。
	 * 
	 * @param <T>
	 *            {@code Set} 中保存的对象。
	 * @param c
	 *            其中的元素将存放在新的 {@code set} 中的 {@code collection}。
	 * @return 返回 {@code java.util.Set<T>} 关于 {@code java.util.TreeSet<T>}
	 *         实现的新实例。
	 */
	public static <T> Set<T> getTreeSet(Collection<? extends T> c) {
		if (CollectionUtils.isEmpty(c))
			return new TreeSet<T>();
		return new TreeSet<T>(c);
	}

	/**
	 * 用该方法来代替 {@code new LinkedList<E>()} 方式获得新的 {@code java.util.Queue} 的实例对象。
	 * 
	 * @param <E>
	 *            {@code Queue<E>} 中保存的对象。
	 * @return 返回 {@code java.util.Queue<E>} 关于 {@code java.util.LinkedList<E>}
	 *         实现的新实例。
	 */
	public static <E> Queue<E> getQueue() {
		return new LinkedList<E>();
	}

	/**
	 * 合并两个有相同元素类型的 {@code java.util.Set}。
	 * <ul>
	 * <li>{@code setA == null && setB == null} --> 返回 {@link #getHashSet()}。</li>
	 * <li>{@code setA != null && setB == null} --> 返回 {@code setA}。</li>
	 * <li>{@code setA == null && setB != null} --> 返回 {@code setB}。</li>
	 * <li>{@code setA != null && setB != null} --> 返回 {@code setA} 和
	 * {@code setB} 的并集。</li>
	 * </ul>
	 * 
	 * @param <T>
	 *            {@code Set} 中保存的对象。
	 * @param setA
	 *            第一个 {@code Set}。
	 * @param setB
	 *            第二个 {@code Set}。
	 * @return 返回 {@code setA} 和 {@code setB} 的并集。
	 */
	public static <T> Set<T> unionHashSet(Set<T> setA, Set<T> setB) {
		boolean isEmptySetA = CollectionUtils.isEmpty(setA);
		boolean isEmptySetB = CollectionUtils.isEmpty(setB);
		if (isEmptySetA && isEmptySetB)
			return getHashSet();
		if (isEmptySetA && !isEmptySetB)
			return setB;
		if (!isEmptySetA && isEmptySetB)
			return setA;
		Set<T> result = getHashSet(setA);
		result.addAll(setB);
		return result;
	}

	/**
	 * 取两个有相同元素类型的 {@code java.util.Set} 的交集，即公共部份的新的 {@code java.util.Set}。
	 * <ul>
	 * <li>{@code setA == null && setB == null} --> 返回 {@code null}。</li>
	 * <li>{@code setA != null && setB == null} --> 返回 {@code null}。</li>
	 * <li>{@code setA == null && setB != null} --> 返回 {@code null}。</li>
	 * <li>{@code setA != null && setB != null} --> 返回 {@code setA} 和
	 * {@code setB} 的交集。</li>
	 * </ul>
	 * 
	 * @param <T>
	 *            {@code Set} 中保存的对象。
	 * @param setA
	 *            第一个 {@code Set}。
	 * @param setB
	 *            第二个 {@code Set}。
	 * @return 返回 {@code setA} 和 {@code setB} 的交集。
	 */
	public static <T> Set<T> intersectHashSet(Set<T> setA, Set<T> setB) {
		if (CollectionUtils.isEmpty(setA) || CollectionUtils.isEmpty(setB))
			return null;
		Set<T> result = getHashSet(setA);
		result.retainAll(setB);
		return result;
	}

	/**
	 * 移除 {@code setA} 中那些包含在 {@code setB} 中的元素。<br />
	 * 此方法不会修改 {@code setA}，只是复制一份作相应操作，返回的是全新的 {@code Set} 对象。
	 * <ul>
	 * <li>{@code setA == null} --> 返回 {@code null}。</li>
	 * <li>{@code setB == null} --> 返回 {@code setA}。</li>
	 * <li>{@code setA != null && setB != null} --> 返回 {@code setA} 和
	 * {@code setB} 的不对称差集。</li>
	 * </ul>
	 * 
	 * @param <T>
	 *            {@code Set} 中保存的对象。
	 * @param setA
	 *            第一个 {@code Set}。
	 * @param setB
	 *            第二个 {@code Set}。
	 * @return 返回 {@code setA} 和 {@code setB} 的不对称差集。
	 */
	public static <T> Set<T> differenceHashSet(Set<T> setA, Set<T> setB) {
		if (CollectionUtils.isEmpty(setA))
			return null;
		if (CollectionUtils.isEmpty(setB))
			return setA;
		Set<T> result = getHashSet(setA);
		result.removeAll(setB);
		return result;
	}

	/**
	 * 取两个有相同元素类型的 {@code java.util.Set} 的补集。
	 * 
	 * @param <T>
	 *            {@code Set} 中保存的对象。
	 * @param setA
	 *            第一个 {@code Set}。
	 * @param setB
	 *            第二个 {@code Set}。
	 * @return 返回 {@code setA} 和 {@code setB} 的补集。
	 */
	public static <T> Set<T> complementHashSet(Set<T> setA, Set<T> setB) {
		return differenceHashSet(unionHashSet(setA, setB),
				intersectHashSet(setA, setB));
	}

	/**
	 * 以 conjunction 为分隔符将集合转换为字符串
	 * 
	 * @param <T>
	 *            被处理的集合
	 * @param collection
	 *            集合
	 * @param conjunction
	 *            分隔符
	 * @return 连接后的字符串
	 */
	public static <T> String join(Iterable<T> collection, String conjunction) {
		StringBuilder sb = new StringBuilder();
		boolean isFirst = true;
		for (T item : collection) {
			if (isFirst) {
				isFirst = false;
			} else {
				sb.append(conjunction);
			}
			sb.append(item);
		}
		return sb.toString();
	}

	/**
	 * 以 conjunction 为分隔符将数组转换为字符串
	 * 
	 * @param <T>
	 *            被处理的集合
	 * @param array
	 *            数组
	 * @param conjunction
	 *            分隔符
	 * @return 连接后的字符串
	 */
	public static <T> String join(T[] array, String conjunction) {
		StringBuilder sb = new StringBuilder();
		boolean isFirst = true;
		for (T item : array) {
			if (isFirst) {
				isFirst = false;
			} else {
				sb.append(conjunction);
			}
			sb.append(item);
		}
		return sb.toString();
	}

	/**
	 * 将新元素添加到已有数组中<br/>
	 * 添加新元素会生成一个新的数组，不影响原数组
	 * 
	 * @param buffer
	 *            已有数组
	 * @param newElement
	 *            新元素
	 * @return 新数组
	 */
	public static <T> T[] append(T[] buffer, T newElement) {
		T[] t = resize(buffer, buffer.length + 1, newElement.getClass());
		t[buffer.length] = newElement;
		return t;
	}

	/**
	 * 生成一个新的重新设置大小的数组
	 * 
	 * @param buffer
	 *            原数组
	 * @param newSize
	 *            新的数组大小
	 * @param componentType
	 *            数组元素类型
	 * @return 调整后的新数组
	 */
	@SuppressWarnings({ "unchecked" })
	public static <T> T[] resize(T[] buffer, int newSize, Class<?> componentType) {
		// 给定类型为空时，使用原数组的类型

		if (componentType == null) {
			componentType = buffer.getClass().getComponentType();
		}
		T[] newArray = (T[]) Array.newInstance(componentType, newSize);
		System.arraycopy(buffer, 0, newArray, 0,
				buffer.length >= newSize ? newSize : buffer.length);
		return newArray;
	}

	/**
	 * 生成一个新的重新设置大小的数组<br/>
	 * 新数组的类型为原数组的类型
	 * 
	 * @param buffer
	 *            原数组
	 * @param newSize
	 *            新的数组大小
	 * @return 调整后的新数组
	 */
	public static <T> T[] resize(T[] buffer, int newSize) {
		return resize(buffer, newSize, null);
	}

}